{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "This exercise is analogous to the SVM exercise. You will:\n",
    "\n",
    "- implement a fully-vectorized **loss function** for the Softmax classifier\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** with numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the linear classifier. These are the same steps as we used for the\n",
    "    SVM, but condensed to a single function.  \n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    \n",
    "    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "    try:\n",
    "       del X_train, y_train\n",
    "       del X_test, y_test\n",
    "       print('Clear previously loaded data.')\n",
    "    except:\n",
    "       pass\n",
    "\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "    X_dev = X_train[mask]\n",
    "    y_dev = y_train[mask]\n",
    "    \n",
    "    # Preprocessing: reshape the image data into rows\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "    \n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis = 0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "    X_dev -= mean_image\n",
    "    \n",
    "    # add bias dimension and transform into columns\n",
    "    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)\n",
    "print('dev data shape: ', X_dev.shape)\n",
    "print('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Softmax Classifier\n",
    "\n",
    "Your code for this section will all be written inside `cs231n/classifiers/softmax.py`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.443775\n",
      "sanity check: 2.302585\n"
     ]
    }
   ],
   "source": [
    "# First implement the naive softmax loss function with nested loops.\n",
    "# Open the file cs231n/classifiers/softmax.py and implement the\n",
    "# softmax_loss_naive function.\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "import time\n",
    "\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 1**\n",
    "\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ *Fill this in* \n",
    "\n",
    "- W各元素接近0，exp(0)=1，带入公式可得\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: -1.571225 analytic: -1.571225, relative error: 6.988773e-09\n",
      "numerical: 1.146764 analytic: 1.146764, relative error: 6.755794e-08\n",
      "numerical: 3.204451 analytic: 3.204451, relative error: 1.104916e-08\n",
      "numerical: 3.199367 analytic: 3.199367, relative error: 1.170912e-08\n",
      "numerical: 3.505783 analytic: 3.505782, relative error: 8.683027e-09\n",
      "numerical: -3.793733 analytic: -3.793733, relative error: 7.578944e-09\n",
      "numerical: -6.408841 analytic: -6.408841, relative error: 6.914029e-09\n",
      "numerical: -0.110553 analytic: -0.110553, relative error: 1.114473e-07\n",
      "numerical: -1.690444 analytic: -1.690444, relative error: 2.055361e-08\n",
      "numerical: -0.151656 analytic: -0.151656, relative error: 3.479722e-07\n",
      "numerical: -4.595109 analytic: -4.595109, relative error: 5.484929e-10\n",
      "numerical: 1.554720 analytic: 1.554720, relative error: 1.800776e-08\n",
      "numerical: 1.909753 analytic: 1.909753, relative error: 2.969731e-08\n",
      "numerical: 0.212605 analytic: 0.212605, relative error: 2.452183e-07\n",
      "numerical: -2.637286 analytic: -2.637286, relative error: 7.820828e-09\n",
      "numerical: 2.483699 analytic: 2.483699, relative error: 1.538547e-08\n",
      "numerical: -0.363698 analytic: -0.363698, relative error: 1.569386e-07\n",
      "numerical: 1.505118 analytic: 1.505118, relative error: 1.114219e-08\n",
      "numerical: -1.276020 analytic: -1.276020, relative error: 3.383783e-08\n",
      "numerical: 3.163531 analytic: 3.163531, relative error: 3.064845e-09\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)\n",
    "\n",
    "# similar to SVM case, do another gradient check with regularization\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.443775e+00 computed in 0.108706s\n",
      "vectorized loss: 2.443775e+00 computed in 0.005540s\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n",
    "# of the gradient.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 0 / 1500: loss 5.592751\n",
      "iteration 100 / 1500: loss 2.472199\n",
      "iteration 200 / 1500: loss 3.108414\n",
      "iteration 300 / 1500: loss 2.772482\n",
      "iteration 400 / 1500: loss 4.148579\n",
      "iteration 500 / 1500: loss 2.307516\n",
      "iteration 600 / 1500: loss 2.796673\n",
      "iteration 700 / 1500: loss 2.645956\n",
      "iteration 800 / 1500: loss 3.211544\n",
      "iteration 900 / 1500: loss 3.853479\n",
      "iteration 1000 / 1500: loss 2.983322\n",
      "iteration 1100 / 1500: loss 2.335345\n",
      "iteration 1200 / 1500: loss 2.761209\n",
      "iteration 1300 / 1500: loss 2.494161\n",
      "iteration 1400 / 1500: loss 2.369269\n",
      "That took 11.981943s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# CREATED BY MYSELF -- learning rate selection\n",
    "from cs231n.classifiers import Softmax\n",
    "softmax_clf = Softmax()\n",
    "\n",
    "tic = time.time()\n",
    "\n",
    "loss_history = softmax_clf.train(X_train, y_train, learning_rate=5e-7, reg=1e-5, num_iters=1500, verbose=True)\n",
    "\n",
    "toc = time.time()\n",
    "\n",
    "print('That took %fs' % (toc - tic))\n",
    "\n",
    "plt.plot(loss_history)\n",
    "plt.xlabel('#Iteration')\n",
    "plt.ylabel('Loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "id": "tuning",
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 5.000000e-08 reg 1.000000e+03 train accuracy: 0.150612 val accuracy: 0.142000\n",
      "lr 5.000000e-08 reg 1.000000e+04 train accuracy: 0.129490 val accuracy: 0.108000\n",
      "lr 5.000000e-08 reg 1.000000e+05 train accuracy: 0.200490 val accuracy: 0.217000\n",
      "lr 5.000000e-08 reg 1.000000e+06 train accuracy: 0.246367 val accuracy: 0.258000\n",
      "lr 5.000000e-08 reg 1.000000e+07 train accuracy: 0.240714 val accuracy: 0.246000\n",
      "lr 1.000000e-07 reg 1.000000e+03 train accuracy: 0.174612 val accuracy: 0.194000\n",
      "lr 1.000000e-07 reg 1.000000e+04 train accuracy: 0.170959 val accuracy: 0.180000\n",
      "lr 1.000000e-07 reg 1.000000e+05 train accuracy: 0.275592 val accuracy: 0.293000\n",
      "lr 1.000000e-07 reg 1.000000e+06 train accuracy: 0.255082 val accuracy: 0.258000\n",
      "lr 1.000000e-07 reg 1.000000e+07 train accuracy: 0.136694 val accuracy: 0.121000\n",
      "lr 5.000000e-07 reg 1.000000e+03 train accuracy: 0.236837 val accuracy: 0.225000\n",
      "lr 5.000000e-07 reg 1.000000e+04 train accuracy: 0.329776 val accuracy: 0.336000\n",
      "lr 5.000000e-07 reg 1.000000e+05 train accuracy: 0.285857 val accuracy: 0.287000\n",
      "lr 5.000000e-07 reg 1.000000e+06 train accuracy: 0.238510 val accuracy: 0.250000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\JupyterNotes\\assignment1\\cs231n\\classifiers\\softmax.py:96: RuntimeWarning: divide by zero encountered in log\n",
      "D:\\JupyterNotes\\assignment1\\cs231n\\classifiers\\softmax.py:100: RuntimeWarning: overflow encountered in double_scalars\n",
      "D:\\Anaconda3\\lib\\site-packages\\numpy\\core\\fromnumeric.py:86: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\JupyterNotes\\assignment1\\cs231n\\classifiers\\softmax.py:100: RuntimeWarning: overflow encountered in multiply\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 5.000000e-07 reg 1.000000e+07 train accuracy: 0.093980 val accuracy: 0.084000\n",
      "lr 1.000000e-06 reg 1.000000e+03 train accuracy: 0.286592 val accuracy: 0.279000\n",
      "lr 1.000000e-06 reg 1.000000e+04 train accuracy: 0.349469 val accuracy: 0.362000\n",
      "lr 1.000000e-06 reg 1.000000e+05 train accuracy: 0.270857 val accuracy: 0.279000\n",
      "lr 1.000000e-06 reg 1.000000e+06 train accuracy: 0.110755 val accuracy: 0.112000\n",
      "lr 1.000000e-06 reg 1.000000e+07 train accuracy: 0.116531 val accuracy: 0.121000\n",
      "lr 5.000000e-06 reg 1.000000e+03 train accuracy: 0.349286 val accuracy: 0.337000\n",
      "lr 5.000000e-06 reg 1.000000e+04 train accuracy: 0.274612 val accuracy: 0.289000\n",
      "lr 5.000000e-06 reg 1.000000e+05 train accuracy: 0.072367 val accuracy: 0.052000\n",
      "lr 5.000000e-06 reg 1.000000e+06 train accuracy: 0.122265 val accuracy: 0.131000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\JupyterNotes\\assignment1\\cs231n\\classifiers\\softmax.py:108: RuntimeWarning: overflow encountered in multiply\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 5.000000e-06 reg 1.000000e+07 train accuracy: 0.100265 val accuracy: 0.087000\n",
      "best validation accuracy achieved during cross-validation: 0.362000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of over 0.35 on the validation set.\n",
    "\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\n",
    "\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained softmax classifer in best_softmax.                          #\n",
    "################################################################################\n",
    "\n",
    "# Provided as a reference. You may or may not want to change these hyperparameters\n",
    "learning_rates = [5e-8, 5e-6]\n",
    "regularization_strengths = [1, 1e5]\n",
    "\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "# follow the same steps in svm.ipynb: \n",
    "# first select learning rate that makes lose go down, \n",
    "# then select the regularization strength by cross-validation\n",
    "\n",
    "for lr in [5e-8, 1e-7, 5e-7, 1e-6, 5e-6]:\n",
    "    # instead of   np.linspace(learning_rates[0], learning_rates[1], num=5)\n",
    "    for reg in [1e3, 1e4, 1e5, 1e6, 1e7]:\n",
    "    # instead of   np.linspace(regularization_strengths[0], regularization_strengths[1], num=5)\n",
    "        softmax_clf = Softmax()\n",
    "        softmax_clf.train(X_train, y_train, learning_rate=lr, reg=reg, num_iters=200)\n",
    "        y_train_pred = softmax_clf.predict(X_train)\n",
    "        y_val_pred = softmax_clf.predict(X_val)\n",
    "        train_acc = np.mean(y_train_pred == y_train)\n",
    "        val_acc = np.mean(y_val_pred == y_val)\n",
    "        \n",
    "        print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_acc, val_acc))\n",
    "        \n",
    "        if val_acc > best_val:\n",
    "            best_val = val_acc\n",
    "            best_softmax = softmax_clf\n",
    "\n",
    "pass\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "id": "test"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.333000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 2** - *True or False*\n",
    "\n",
    "Suppose the overall training loss is defined as the sum of the per-datapoint loss over all training examples. It is possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$\n",
    "\n",
    "\n",
    "$\\color{blue}{\\textit Your Explanation:}$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    \n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
